home *** CD-ROM | disk | FTP | other *** search
/ Chip 2007 January, February, March & April / Chip-Cover-CD-2007-02.iso / Pakiet bezpieczenstwa / mini Pentoo LiveCD 2006.1 / mpentoo-2006.1.iso / livecd.squashfs / usr / include / linux / jbd.h < prev    next >
C/C++ Source or Header  |  2005-10-13  |  33KB  |  1,090 lines
  1. /*
  2.  * linux/include/linux/jbd.h
  3.  * 
  4.  * Written by Stephen C. Tweedie <sct@redhat.com>
  5.  *
  6.  * Copyright 1998-2000 Red Hat, Inc --- All Rights Reserved
  7.  *
  8.  * This file is part of the Linux kernel and is made available under
  9.  * the terms of the GNU General Public License, version 2, or at your
  10.  * option, any later version, incorporated herein by reference.
  11.  *
  12.  * Definitions for transaction data structures for the buffer cache
  13.  * filesystem journaling support.
  14.  */
  15.  
  16. #ifndef _LINUX_JBD_H
  17. #define _LINUX_JBD_H
  18.  
  19. #if defined(CONFIG_JBD) || defined(CONFIG_JBD_MODULE) || !defined(__KERNEL__)
  20.  
  21. /* Allow this file to be included directly into e2fsprogs */
  22. #ifndef __KERNEL__
  23. #include "jfs_compat.h"
  24. #define JFS_DEBUG
  25. #define jfs_debug jbd_debug
  26. #else
  27.  
  28. #include <linux/buffer_head.h>
  29. #include <linux/journal-head.h>
  30. #include <linux/stddef.h>
  31. #include <asm/semaphore.h>
  32. #endif
  33.  
  34. #define journal_oom_retry 1
  35.  
  36. /*
  37.  * Define JBD_PARANIOD_IOFAIL to cause a kernel BUG() if ext3 finds
  38.  * certain classes of error which can occur due to failed IOs.  Under
  39.  * normal use we want ext3 to continue after such errors, because
  40.  * hardware _can_ fail, but for debugging purposes when running tests on
  41.  * known-good hardware we may want to trap these errors.
  42.  */
  43. #undef JBD_PARANOID_IOFAIL
  44.  
  45. /*
  46.  * The default maximum commit age, in seconds.
  47.  */
  48. #define JBD_DEFAULT_MAX_COMMIT_AGE 5
  49.  
  50. #ifdef CONFIG_JBD_DEBUG
  51. /*
  52.  * Define JBD_EXPENSIVE_CHECKING to enable more expensive internal
  53.  * consistency checks.  By default we don't do this unless
  54.  * CONFIG_JBD_DEBUG is on.
  55.  */
  56. #define JBD_EXPENSIVE_CHECKING
  57. extern int journal_enable_debug;
  58.  
  59. #define jbd_debug(n, f, a...)                        \
  60.     do {                                \
  61.         if ((n) <= journal_enable_debug) {            \
  62.             printk (KERN_DEBUG "(%s, %d): %s: ",        \
  63.                 __FILE__, __LINE__, __FUNCTION__);    \
  64.               printk (f, ## a);                \
  65.         }                            \
  66.     } while (0)
  67. #else
  68. #define jbd_debug(f, a...)    /**/
  69. #endif
  70.  
  71. extern void * __jbd_kmalloc (const char *where, size_t size, int flags, int retry);
  72. #define jbd_kmalloc(size, flags) \
  73.     __jbd_kmalloc(__FUNCTION__, (size), (flags), journal_oom_retry)
  74. #define jbd_rep_kmalloc(size, flags) \
  75.     __jbd_kmalloc(__FUNCTION__, (size), (flags), 1)
  76.  
  77. #define JFS_MIN_JOURNAL_BLOCKS 1024
  78.  
  79. #ifdef __KERNEL__
  80.  
  81. /**
  82.  * typedef handle_t - The handle_t type represents a single atomic update being performed by some process.
  83.  *
  84.  * All filesystem modifications made by the process go
  85.  * through this handle.  Recursive operations (such as quota operations)
  86.  * are gathered into a single update.
  87.  *
  88.  * The buffer credits field is used to account for journaled buffers
  89.  * being modified by the running process.  To ensure that there is
  90.  * enough log space for all outstanding operations, we need to limit the
  91.  * number of outstanding buffers possible at any time.  When the
  92.  * operation completes, any buffer credits not used are credited back to
  93.  * the transaction, so that at all times we know how many buffers the
  94.  * outstanding updates on a transaction might possibly touch. 
  95.  * 
  96.  * This is an opaque datatype.
  97.  **/
  98. typedef struct handle_s        handle_t;    /* Atomic operation type */
  99.  
  100.  
  101. /**
  102.  * typedef journal_t - The journal_t maintains all of the journaling state information for a single filesystem.
  103.  *
  104.  * journal_t is linked to from the fs superblock structure.
  105.  * 
  106.  * We use the journal_t to keep track of all outstanding transaction
  107.  * activity on the filesystem, and to manage the state of the log
  108.  * writing process.
  109.  *
  110.  * This is an opaque datatype.
  111.  **/
  112. typedef struct journal_s    journal_t;    /* Journal control structure */
  113. #endif
  114.  
  115. /*
  116.  * Internal structures used by the logging mechanism:
  117.  */
  118.  
  119. #define JFS_MAGIC_NUMBER 0xc03b3998U /* The first 4 bytes of /dev/random! */
  120.  
  121. /*
  122.  * On-disk structures
  123.  */
  124.  
  125. /* 
  126.  * Descriptor block types:
  127.  */
  128.  
  129. #define JFS_DESCRIPTOR_BLOCK    1
  130. #define JFS_COMMIT_BLOCK    2
  131. #define JFS_SUPERBLOCK_V1    3
  132. #define JFS_SUPERBLOCK_V2    4
  133. #define JFS_REVOKE_BLOCK    5
  134.  
  135. /*
  136.  * Standard header for all descriptor blocks:
  137.  */
  138. typedef struct journal_header_s
  139. {
  140.     __be32        h_magic;
  141.     __be32        h_blocktype;
  142.     __be32        h_sequence;
  143. } journal_header_t;
  144.  
  145.  
  146. /* 
  147.  * The block tag: used to describe a single buffer in the journal 
  148.  */
  149. typedef struct journal_block_tag_s
  150. {
  151.     __be32        t_blocknr;    /* The on-disk block number */
  152.     __be32        t_flags;    /* See below */
  153. } journal_block_tag_t;
  154.  
  155. /* 
  156.  * The revoke descriptor: used on disk to describe a series of blocks to
  157.  * be revoked from the log 
  158.  */
  159. typedef struct journal_revoke_header_s
  160. {
  161.     journal_header_t r_header;
  162.     __be32         r_count;    /* Count of bytes used in the block */
  163. } journal_revoke_header_t;
  164.  
  165.  
  166. /* Definitions for the journal tag flags word: */
  167. #define JFS_FLAG_ESCAPE        1    /* on-disk block is escaped */
  168. #define JFS_FLAG_SAME_UUID    2    /* block has same uuid as previous */
  169. #define JFS_FLAG_DELETED    4    /* block deleted by this transaction */
  170. #define JFS_FLAG_LAST_TAG    8    /* last tag in this descriptor block */
  171.  
  172.  
  173. /*
  174.  * The journal superblock.  All fields are in big-endian byte order.
  175.  */
  176. typedef struct journal_superblock_s
  177. {
  178. /* 0x0000 */
  179.     journal_header_t s_header;
  180.  
  181. /* 0x000C */
  182.     /* Static information describing the journal */
  183.     __be32    s_blocksize;        /* journal device blocksize */
  184.     __be32    s_maxlen;        /* total blocks in journal file */
  185.     __be32    s_first;        /* first block of log information */
  186.  
  187. /* 0x0018 */
  188.     /* Dynamic information describing the current state of the log */
  189.     __be32    s_sequence;        /* first commit ID expected in log */
  190.     __be32    s_start;        /* blocknr of start of log */
  191.  
  192. /* 0x0020 */
  193.     /* Error value, as set by journal_abort(). */
  194.     __be32    s_errno;
  195.  
  196. /* 0x0024 */
  197.     /* Remaining fields are only valid in a version-2 superblock */
  198.     __be32    s_feature_compat;     /* compatible feature set */
  199.     __be32    s_feature_incompat;     /* incompatible feature set */
  200.     __be32    s_feature_ro_compat;     /* readonly-compatible feature set */
  201. /* 0x0030 */
  202.     __u8    s_uuid[16];        /* 128-bit uuid for journal */
  203.  
  204. /* 0x0040 */
  205.     __be32    s_nr_users;        /* Nr of filesystems sharing log */
  206.  
  207.     __be32    s_dynsuper;        /* Blocknr of dynamic superblock copy*/
  208.  
  209. /* 0x0048 */
  210.     __be32    s_max_transaction;    /* Limit of journal blocks per trans.*/
  211.     __be32    s_max_trans_data;    /* Limit of data blocks per trans. */
  212.  
  213. /* 0x0050 */
  214.     __u32    s_padding[44];
  215.  
  216. /* 0x0100 */
  217.     __u8    s_users[16*48];        /* ids of all fs'es sharing the log */
  218. /* 0x0400 */
  219. } journal_superblock_t;
  220.  
  221. #define JFS_HAS_COMPAT_FEATURE(j,mask)                    \
  222.     ((j)->j_format_version >= 2 &&                    \
  223.      ((j)->j_superblock->s_feature_compat & cpu_to_be32((mask))))
  224. #define JFS_HAS_RO_COMPAT_FEATURE(j,mask)                \
  225.     ((j)->j_format_version >= 2 &&                    \
  226.      ((j)->j_superblock->s_feature_ro_compat & cpu_to_be32((mask))))
  227. #define JFS_HAS_INCOMPAT_FEATURE(j,mask)                \
  228.     ((j)->j_format_version >= 2 &&                    \
  229.      ((j)->j_superblock->s_feature_incompat & cpu_to_be32((mask))))
  230.  
  231. #define JFS_FEATURE_INCOMPAT_REVOKE    0x00000001
  232.  
  233. /* Features known to this kernel version: */
  234. #define JFS_KNOWN_COMPAT_FEATURES    0
  235. #define JFS_KNOWN_ROCOMPAT_FEATURES    0
  236. #define JFS_KNOWN_INCOMPAT_FEATURES    JFS_FEATURE_INCOMPAT_REVOKE
  237.  
  238. #ifdef __KERNEL__
  239.  
  240. #include <linux/fs.h>
  241. #include <linux/sched.h>
  242. #include <asm/bug.h>
  243.  
  244. #define JBD_ASSERTIONS
  245. #ifdef JBD_ASSERTIONS
  246. #define J_ASSERT(assert)                        \
  247. do {                                    \
  248.     if (!(assert)) {                        \
  249.         printk (KERN_EMERG                    \
  250.             "Assertion failure in %s() at %s:%d: \"%s\"\n",    \
  251.             __FUNCTION__, __FILE__, __LINE__, # assert);    \
  252.         BUG();                            \
  253.     }                                \
  254. } while (0)
  255.  
  256. #if defined(CONFIG_BUFFER_DEBUG)
  257. void buffer_assertion_failure(struct buffer_head *bh);
  258. #define J_ASSERT_BH(bh, expr)                        \
  259.     do {                                \
  260.         if (!(expr))                        \
  261.             buffer_assertion_failure(bh);            \
  262.         J_ASSERT(expr);                        \
  263.     } while (0)
  264. #define J_ASSERT_JH(jh, expr)    J_ASSERT_BH(jh2bh(jh), expr)
  265. #else
  266. #define J_ASSERT_BH(bh, expr)    J_ASSERT(expr)
  267. #define J_ASSERT_JH(jh, expr)    J_ASSERT(expr)
  268. #endif
  269.  
  270. #else
  271. #define J_ASSERT(assert)    do { } while (0)
  272. #endif        /* JBD_ASSERTIONS */
  273.  
  274. #if defined(JBD_PARANOID_IOFAIL)
  275. #define J_EXPECT(expr, why...)        J_ASSERT(expr)
  276. #define J_EXPECT_BH(bh, expr, why...)    J_ASSERT_BH(bh, expr)
  277. #define J_EXPECT_JH(jh, expr, why...)    J_ASSERT_JH(jh, expr)
  278. #else
  279. #define __journal_expect(expr, why...)                         \
  280.     ({                                     \
  281.         int val = (expr);                         \
  282.         if (!val) {                             \
  283.             printk(KERN_ERR                         \
  284.                 "EXT3-fs unexpected failure: %s;\n",# expr); \
  285.             printk(KERN_ERR why "\n");                 \
  286.         }                                 \
  287.         val;                                 \
  288.     })
  289. #define J_EXPECT(expr, why...)        __journal_expect(expr, ## why)
  290. #define J_EXPECT_BH(bh, expr, why...)    __journal_expect(expr, ## why)
  291. #define J_EXPECT_JH(jh, expr, why...)    __journal_expect(expr, ## why)
  292. #endif
  293.  
  294. enum jbd_state_bits {
  295.     BH_JBD            /* Has an attached ext3 journal_head */
  296.       = BH_PrivateStart,
  297.     BH_JWrite,        /* Being written to log (@@@ DEBUGGING) */
  298.     BH_Freed,        /* Has been freed (truncated) */
  299.     BH_Revoked,        /* Has been revoked from the log */
  300.     BH_RevokeValid,        /* Revoked flag is valid */
  301.     BH_JBDDirty,        /* Is dirty but journaled */
  302.     BH_State,        /* Pins most journal_head state */
  303.     BH_JournalHead,        /* Pins bh->b_private and jh->b_bh */
  304.     BH_Unshadow,        /* Dummy bit, for BJ_Shadow wakeup filtering */
  305. };
  306.  
  307. BUFFER_FNS(JBD, jbd)
  308. BUFFER_FNS(JWrite, jwrite)
  309. BUFFER_FNS(JBDDirty, jbddirty)
  310. TAS_BUFFER_FNS(JBDDirty, jbddirty)
  311. BUFFER_FNS(Revoked, revoked)
  312. TAS_BUFFER_FNS(Revoked, revoked)
  313. BUFFER_FNS(RevokeValid, revokevalid)
  314. TAS_BUFFER_FNS(RevokeValid, revokevalid)
  315. BUFFER_FNS(Freed, freed)
  316.  
  317. static inline struct buffer_head *jh2bh(struct journal_head *jh)
  318. {
  319.     return jh->b_bh;
  320. }
  321.  
  322. static inline struct journal_head *bh2jh(struct buffer_head *bh)
  323. {
  324.     return bh->b_private;
  325. }
  326.  
  327. static inline void jbd_lock_bh_state(struct buffer_head *bh)
  328. {
  329.     bit_spin_lock(BH_State, &bh->b_state);
  330. }
  331.  
  332. static inline int jbd_trylock_bh_state(struct buffer_head *bh)
  333. {
  334.     return bit_spin_trylock(BH_State, &bh->b_state);
  335. }
  336.  
  337. static inline int jbd_is_locked_bh_state(struct buffer_head *bh)
  338. {
  339.     return bit_spin_is_locked(BH_State, &bh->b_state);
  340. }
  341.  
  342. static inline void jbd_unlock_bh_state(struct buffer_head *bh)
  343. {
  344.     bit_spin_unlock(BH_State, &bh->b_state);
  345. }
  346.  
  347. static inline void jbd_lock_bh_journal_head(struct buffer_head *bh)
  348. {
  349.     bit_spin_lock(BH_JournalHead, &bh->b_state);
  350. }
  351.  
  352. static inline void jbd_unlock_bh_journal_head(struct buffer_head *bh)
  353. {
  354.     bit_spin_unlock(BH_JournalHead, &bh->b_state);
  355. }
  356.  
  357. struct jbd_revoke_table_s;
  358.  
  359. /**
  360.  * struct handle_s - The handle_s type is the concrete type associated with
  361.  *     handle_t.
  362.  * @h_transaction: Which compound transaction is this update a part of?
  363.  * @h_buffer_credits: Number of remaining buffers we are allowed to dirty.
  364.  * @h_ref: Reference count on this handle
  365.  * @h_err: Field for caller's use to track errors through large fs operations
  366.  * @h_sync: flag for sync-on-close
  367.  * @h_jdata: flag to force data journaling
  368.  * @h_aborted: flag indicating fatal error on handle
  369.  **/
  370.  
  371. /* Docbook can't yet cope with the bit fields, but will leave the documentation
  372.  * in so it can be fixed later. 
  373.  */
  374.  
  375. struct handle_s 
  376. {
  377.     /* Which compound transaction is this update a part of? */
  378.     transaction_t        *h_transaction;
  379.  
  380.     /* Number of remaining buffers we are allowed to dirty: */
  381.     int            h_buffer_credits;
  382.  
  383.     /* Reference count on this handle */
  384.     int            h_ref;
  385.  
  386.     /* Field for caller's use to track errors through large fs */
  387.     /* operations */
  388.     int            h_err;
  389.  
  390.     /* Flags [no locking] */
  391.     unsigned int    h_sync:        1;    /* sync-on-close */
  392.     unsigned int    h_jdata:    1;    /* force data journaling */
  393.     unsigned int    h_aborted:    1;    /* fatal error on handle */
  394. };
  395.  
  396.  
  397. /* The transaction_t type is the guts of the journaling mechanism.  It
  398.  * tracks a compound transaction through its various states:
  399.  *
  400.  * RUNNING:    accepting new updates
  401.  * LOCKED:    Updates still running but we don't accept new ones
  402.  * RUNDOWN:    Updates are tidying up but have finished requesting
  403.  *        new buffers to modify (state not used for now)
  404.  * FLUSH:       All updates complete, but we are still writing to disk
  405.  * COMMIT:      All data on disk, writing commit record
  406.  * FINISHED:    We still have to keep the transaction for checkpointing.
  407.  *
  408.  * The transaction keeps track of all of the buffers modified by a
  409.  * running transaction, and all of the buffers committed but not yet
  410.  * flushed to home for finished transactions.
  411.  */
  412.  
  413. /*
  414.  * Lock ranking:
  415.  *
  416.  *    j_list_lock
  417.  *      ->jbd_lock_bh_journal_head()    (This is "innermost")
  418.  *
  419.  *    j_state_lock
  420.  *    ->jbd_lock_bh_state()
  421.  *
  422.  *    jbd_lock_bh_state()
  423.  *    ->j_list_lock
  424.  *
  425.  *    j_state_lock
  426.  *    ->t_handle_lock
  427.  *
  428.  *    j_state_lock
  429.  *    ->j_list_lock            (journal_unmap_buffer)
  430.  *
  431.  */
  432.  
  433. struct transaction_s 
  434. {
  435.     /* Pointer to the journal for this transaction. [no locking] */
  436.     journal_t        *t_journal;
  437.  
  438.     /* Sequence number for this transaction [no locking] */
  439.     tid_t            t_tid;
  440.  
  441.     /*
  442.      * Transaction's current state
  443.      * [no locking - only kjournald alters this]
  444.      * FIXME: needs barriers
  445.      * KLUDGE: [use j_state_lock]
  446.      */
  447.     enum {
  448.         T_RUNNING,
  449.         T_LOCKED,
  450.         T_RUNDOWN,
  451.         T_FLUSH,
  452.         T_COMMIT,
  453.         T_FINISHED 
  454.     }            t_state;
  455.  
  456.     /*
  457.      * Where in the log does this transaction's commit start? [no locking]
  458.      */
  459.     unsigned long        t_log_start;
  460.  
  461.     /* Number of buffers on the t_buffers list [j_list_lock] */
  462.     int            t_nr_buffers;
  463.  
  464.     /*
  465.      * Doubly-linked circular list of all buffers reserved but not yet
  466.      * modified by this transaction [j_list_lock]
  467.      */
  468.     struct journal_head    *t_reserved_list;
  469.  
  470.     /*
  471.      * Doubly-linked circular list of all buffers under writeout during
  472.      * commit [j_list_lock]
  473.      */
  474.     struct journal_head    *t_locked_list;
  475.  
  476.     /*
  477.      * Doubly-linked circular list of all metadata buffers owned by this
  478.      * transaction [j_list_lock]
  479.      */
  480.     struct journal_head    *t_buffers;
  481.  
  482.     /*
  483.      * Doubly-linked circular list of all data buffers still to be
  484.      * flushed before this transaction can be committed [j_list_lock]
  485.      */
  486.     struct journal_head    *t_sync_datalist;
  487.  
  488.     /*
  489.      * Doubly-linked circular list of all forget buffers (superseded
  490.      * buffers which we can un-checkpoint once this transaction commits)
  491.      * [j_list_lock]
  492.      */
  493.     struct journal_head    *t_forget;
  494.  
  495.     /*
  496.      * Doubly-linked circular list of all buffers still to be flushed before
  497.      * this transaction can be checkpointed. [j_list_lock]
  498.      */
  499.     struct journal_head    *t_checkpoint_list;
  500.  
  501.     /*
  502.      * Doubly-linked circular list of temporary buffers currently undergoing
  503.      * IO in the log [j_list_lock]
  504.      */
  505.     struct journal_head    *t_iobuf_list;
  506.  
  507.     /*
  508.      * Doubly-linked circular list of metadata buffers being shadowed by log
  509.      * IO.  The IO buffers on the iobuf list and the shadow buffers on this
  510.      * list match each other one for one at all times. [j_list_lock]
  511.      */
  512.     struct journal_head    *t_shadow_list;
  513.  
  514.     /*
  515.      * Doubly-linked circular list of control buffers being written to the
  516.      * log. [j_list_lock]
  517.      */
  518.     struct journal_head    *t_log_list;
  519.  
  520.     /*
  521.      * Protects info related to handles
  522.      */
  523.     spinlock_t        t_handle_lock;
  524.  
  525.     /*
  526.      * Number of outstanding updates running on this transaction
  527.      * [t_handle_lock]
  528.      */
  529.     int            t_updates;
  530.  
  531.     /*
  532.      * Number of buffers reserved for use by all handles in this transaction
  533.      * handle but not yet modified. [t_handle_lock]
  534.      */
  535.     int            t_outstanding_credits;
  536.  
  537.     /*
  538.      * Forward and backward links for the circular list of all transactions
  539.      * awaiting checkpoint. [j_list_lock]
  540.      */
  541.     transaction_t        *t_cpnext, *t_cpprev;
  542.  
  543.     /*
  544.      * When will the transaction expire (become due for commit), in jiffies?
  545.      * [no locking]
  546.      */
  547.     unsigned long        t_expires;
  548.  
  549.     /*
  550.      * How many handles used this transaction? [t_handle_lock]
  551.      */
  552.     int t_handle_count;
  553.  
  554. };
  555.  
  556. /**
  557.  * struct journal_s - The journal_s type is the concrete type associated with
  558.  *     journal_t.
  559.  * @j_flags:  General journaling state flags
  560.  * @j_errno:  Is there an outstanding uncleared error on the journal (from a
  561.  *     prior abort)? 
  562.  * @j_sb_buffer: First part of superblock buffer
  563.  * @j_superblock: Second part of superblock buffer
  564.  * @j_format_version: Version of the superblock format
  565.  * @j_barrier_count:  Number of processes waiting to create a barrier lock
  566.  * @j_barrier: The barrier lock itself
  567.  * @j_running_transaction: The current running transaction..
  568.  * @j_committing_transaction: the transaction we are pushing to disk
  569.  * @j_checkpoint_transactions: a linked circular list of all transactions
  570.  *  waiting for checkpointing
  571.  * @j_wait_transaction_locked: Wait queue for waiting for a locked transaction
  572.  *  to start committing, or for a barrier lock to be released
  573.  * @j_wait_logspace: Wait queue for waiting for checkpointing to complete
  574.  * @j_wait_done_commit: Wait queue for waiting for commit to complete 
  575.  * @j_wait_checkpoint:  Wait queue to trigger checkpointing
  576.  * @j_wait_commit: Wait queue to trigger commit
  577.  * @j_wait_updates: Wait queue to wait for updates to complete
  578.  * @j_checkpoint_sem: Semaphore for locking against concurrent checkpoints
  579.  * @j_head: Journal head - identifies the first unused block in the journal
  580.  * @j_tail: Journal tail - identifies the oldest still-used block in the
  581.  *  journal.
  582.  * @j_free: Journal free - how many free blocks are there in the journal?
  583.  * @j_first: The block number of the first usable block 
  584.  * @j_last: The block number one beyond the last usable block
  585.  * @j_dev: Device where we store the journal
  586.  * @j_blocksize: blocksize for the location where we store the journal.
  587.  * @j_blk_offset: starting block offset for into the device where we store the
  588.  *     journal
  589.  * @j_fs_dev: Device which holds the client fs.  For internal journal this will
  590.  *     be equal to j_dev
  591.  * @j_maxlen: Total maximum capacity of the journal region on disk.
  592.  * @j_inode: Optional inode where we store the journal.  If present, all journal
  593.  *     block numbers are mapped into this inode via bmap().
  594.  * @j_tail_sequence:  Sequence number of the oldest transaction in the log 
  595.  * @j_transaction_sequence: Sequence number of the next transaction to grant
  596.  * @j_commit_sequence: Sequence number of the most recently committed
  597.  *  transaction
  598.  * @j_commit_request: Sequence number of the most recent transaction wanting
  599.  *     commit 
  600.  * @j_uuid: Uuid of client object.
  601.  * @j_task: Pointer to the current commit thread for this journal
  602.  * @j_max_transaction_buffers:  Maximum number of metadata buffers to allow in a
  603.  *     single compound commit transaction
  604.  * @j_commit_interval: What is the maximum transaction lifetime before we begin
  605.  *  a commit?
  606.  * @j_commit_timer:  The timer used to wakeup the commit thread
  607.  * @j_revoke: The revoke table - maintains the list of revoked blocks in the
  608.  *     current transaction.
  609.  */
  610.  
  611. struct journal_s
  612. {
  613.     /* General journaling state flags [j_state_lock] */
  614.     unsigned long        j_flags;
  615.  
  616.     /*
  617.      * Is there an outstanding uncleared error on the journal (from a prior
  618.      * abort)? [j_state_lock]
  619.      */
  620.     int            j_errno;
  621.  
  622.     /* The superblock buffer */
  623.     struct buffer_head    *j_sb_buffer;
  624.     journal_superblock_t    *j_superblock;
  625.  
  626.     /* Version of the superblock format */
  627.     int            j_format_version;
  628.  
  629.     /*
  630.      * Protect the various scalars in the journal
  631.      */
  632.     spinlock_t        j_state_lock;
  633.  
  634.     /*
  635.      * Number of processes waiting to create a barrier lock [j_state_lock]
  636.      */
  637.     int            j_barrier_count;
  638.  
  639.     /* The barrier lock itself */
  640.     struct semaphore    j_barrier;
  641.  
  642.     /*
  643.      * Transactions: The current running transaction...
  644.      * [j_state_lock] [caller holding open handle]
  645.      */
  646.     transaction_t        *j_running_transaction;
  647.  
  648.     /*
  649.      * the transaction we are pushing to disk
  650.      * [j_state_lock] [caller holding open handle]
  651.      */
  652.     transaction_t        *j_committing_transaction;
  653.  
  654.     /*
  655.      * ... and a linked circular list of all transactions waiting for
  656.      * checkpointing. [j_list_lock]
  657.      */
  658.     transaction_t        *j_checkpoint_transactions;
  659.  
  660.     /*
  661.      * Wait queue for waiting for a locked transaction to start committing,
  662.      * or for a barrier lock to be released
  663.      */
  664.     wait_queue_head_t    j_wait_transaction_locked;
  665.  
  666.     /* Wait queue for waiting for checkpointing to complete */
  667.     wait_queue_head_t    j_wait_logspace;
  668.  
  669.     /* Wait queue for waiting for commit to complete */
  670.     wait_queue_head_t    j_wait_done_commit;
  671.  
  672.     /* Wait queue to trigger checkpointing */
  673.     wait_queue_head_t    j_wait_checkpoint;
  674.  
  675.     /* Wait queue to trigger commit */
  676.     wait_queue_head_t    j_wait_commit;
  677.  
  678.     /* Wait queue to wait for updates to complete */
  679.     wait_queue_head_t    j_wait_updates;
  680.  
  681.     /* Semaphore for locking against concurrent checkpoints */
  682.     struct semaphore     j_checkpoint_sem;
  683.  
  684.     /*
  685.      * Journal head: identifies the first unused block in the journal.
  686.      * [j_state_lock]
  687.      */
  688.     unsigned long        j_head;
  689.  
  690.     /*
  691.      * Journal tail: identifies the oldest still-used block in the journal.
  692.      * [j_state_lock]
  693.      */
  694.     unsigned long        j_tail;
  695.  
  696.     /*
  697.      * Journal free: how many free blocks are there in the journal?
  698.      * [j_state_lock]
  699.      */
  700.     unsigned long        j_free;
  701.  
  702.     /*
  703.      * Journal start and end: the block numbers of the first usable block
  704.      * and one beyond the last usable block in the journal. [j_state_lock]
  705.      */
  706.     unsigned long        j_first;
  707.     unsigned long        j_last;
  708.  
  709.     /*
  710.      * Device, blocksize and starting block offset for the location where we
  711.      * store the journal.
  712.      */
  713.     struct block_device    *j_dev;
  714.     int            j_blocksize;
  715.     unsigned int        j_blk_offset;
  716.  
  717.     /*
  718.      * Device which holds the client fs.  For internal journal this will be
  719.      * equal to j_dev.
  720.      */
  721.     struct block_device    *j_fs_dev;
  722.  
  723.     /* Total maximum capacity of the journal region on disk. */
  724.     unsigned int        j_maxlen;
  725.  
  726.     /*
  727.      * Protects the buffer lists and internal buffer state.
  728.      */
  729.     spinlock_t        j_list_lock;
  730.  
  731.     /* Optional inode where we store the journal.  If present, all */
  732.     /* journal block numbers are mapped into this inode via */
  733.     /* bmap(). */
  734.     struct inode        *j_inode;
  735.  
  736.     /*
  737.      * Sequence number of the oldest transaction in the log [j_state_lock]
  738.      */
  739.     tid_t            j_tail_sequence;
  740.  
  741.     /*
  742.      * Sequence number of the next transaction to grant [j_state_lock]
  743.      */
  744.     tid_t            j_transaction_sequence;
  745.  
  746.     /*
  747.      * Sequence number of the most recently committed transaction
  748.      * [j_state_lock].
  749.      */
  750.     tid_t            j_commit_sequence;
  751.  
  752.     /*
  753.      * Sequence number of the most recent transaction wanting commit
  754.      * [j_state_lock]
  755.      */
  756.     tid_t            j_commit_request;
  757.  
  758.     /*
  759.      * Journal uuid: identifies the object (filesystem, LVM volume etc)
  760.      * backed by this journal.  This will eventually be replaced by an array
  761.      * of uuids, allowing us to index multiple devices within a single
  762.      * journal and to perform atomic updates across them.
  763.      */
  764.     __u8            j_uuid[16];
  765.  
  766.     /* Pointer to the current commit thread for this journal */
  767.     struct task_struct    *j_task;
  768.  
  769.     /*
  770.      * Maximum number of metadata buffers to allow in a single compound
  771.      * commit transaction
  772.      */
  773.     int            j_max_transaction_buffers;
  774.  
  775.     /*
  776.      * What is the maximum transaction lifetime before we begin a commit?
  777.      */
  778.     unsigned long        j_commit_interval;
  779.  
  780.     /* The timer used to wakeup the commit thread: */
  781.     struct timer_list    *j_commit_timer;
  782.  
  783.     /*
  784.      * The revoke table: maintains the list of revoked blocks in the
  785.      * current transaction.  [j_revoke_lock]
  786.      */
  787.     spinlock_t        j_revoke_lock;
  788.     struct jbd_revoke_table_s *j_revoke;
  789.     struct jbd_revoke_table_s *j_revoke_table[2];
  790.  
  791.     /*
  792.      * An opaque pointer to fs-private information.  ext3 puts its
  793.      * superblock pointer here
  794.      */
  795.     void *j_private;
  796. };
  797.  
  798. /* 
  799.  * Journal flag definitions 
  800.  */
  801. #define JFS_UNMOUNT    0x001    /* Journal thread is being destroyed */
  802. #define JFS_ABORT    0x002    /* Journaling has been aborted for errors. */
  803. #define JFS_ACK_ERR    0x004    /* The errno in the sb has been acked */
  804. #define JFS_FLUSHED    0x008    /* The journal superblock has been flushed */
  805. #define JFS_LOADED    0x010    /* The journal superblock has been loaded */
  806. #define JFS_BARRIER    0x020    /* Use IDE barriers */
  807.  
  808. /* 
  809.  * Function declarations for the journaling transaction and buffer
  810.  * management
  811.  */
  812.  
  813. /* Filing buffers */
  814. extern void journal_unfile_buffer(journal_t *, struct journal_head *);
  815. extern void __journal_unfile_buffer(struct journal_head *);
  816. extern void __journal_refile_buffer(struct journal_head *);
  817. extern void journal_refile_buffer(journal_t *, struct journal_head *);
  818. extern void __journal_file_buffer(struct journal_head *, transaction_t *, int);
  819. extern void __journal_free_buffer(struct journal_head *bh);
  820. extern void journal_file_buffer(struct journal_head *, transaction_t *, int);
  821. extern void __journal_clean_data_list(transaction_t *transaction);
  822.  
  823. /* Log buffer allocation */
  824. extern struct journal_head * journal_get_descriptor_buffer(journal_t *);
  825. int journal_next_log_block(journal_t *, unsigned long *);
  826.  
  827. /* Commit management */
  828. extern void journal_commit_transaction(journal_t *);
  829.  
  830. /* Checkpoint list management */
  831. int __journal_clean_checkpoint_list(journal_t *journal);
  832. void __journal_remove_checkpoint(struct journal_head *);
  833. void __journal_insert_checkpoint(struct journal_head *, transaction_t *);
  834.  
  835. /* Buffer IO */
  836. extern int 
  837. journal_write_metadata_buffer(transaction_t      *transaction,
  838.                   struct journal_head  *jh_in,
  839.                   struct journal_head **jh_out,
  840.                   int           blocknr);
  841.  
  842. /* Transaction locking */
  843. extern void        __wait_on_journal (journal_t *);
  844.  
  845. /*
  846.  * Journal locking.
  847.  *
  848.  * We need to lock the journal during transaction state changes so that nobody
  849.  * ever tries to take a handle on the running transaction while we are in the
  850.  * middle of moving it to the commit phase.  j_state_lock does this.
  851.  *
  852.  * Note that the locking is completely interrupt unsafe.  We never touch
  853.  * journal structures from interrupts.
  854.  */
  855.  
  856. static inline handle_t *journal_current_handle(void)
  857. {
  858.     return current->journal_info;
  859. }
  860.  
  861. /* The journaling code user interface:
  862.  *
  863.  * Create and destroy handles
  864.  * Register buffer modifications against the current transaction. 
  865.  */
  866.  
  867. extern handle_t *journal_start(journal_t *, int nblocks);
  868. extern int     journal_restart (handle_t *, int nblocks);
  869. extern int     journal_extend (handle_t *, int nblocks);
  870. extern int     journal_get_write_access(handle_t *, struct buffer_head *,
  871.                         int *credits);
  872. extern int     journal_get_create_access (handle_t *, struct buffer_head *);
  873. extern int     journal_get_undo_access(handle_t *, struct buffer_head *,
  874.                         int *credits);
  875. extern int     journal_dirty_data (handle_t *, struct buffer_head *);
  876. extern int     journal_dirty_metadata (handle_t *, struct buffer_head *);
  877. extern void     journal_release_buffer (handle_t *, struct buffer_head *,
  878.                         int credits);
  879. extern int     journal_forget (handle_t *, struct buffer_head *);
  880. extern void     journal_sync_buffer (struct buffer_head *);
  881. extern int     journal_invalidatepage(journal_t *,
  882.                 struct page *, unsigned long);
  883. extern int     journal_try_to_free_buffers(journal_t *, struct page *, int);
  884. extern int     journal_stop(handle_t *);
  885. extern int     journal_flush (journal_t *);
  886. extern void     journal_lock_updates (journal_t *);
  887. extern void     journal_unlock_updates (journal_t *);
  888.  
  889. extern journal_t * journal_init_dev(struct block_device *bdev,
  890.                 struct block_device *fs_dev,
  891.                 int start, int len, int bsize);
  892. extern journal_t * journal_init_inode (struct inode *);
  893. extern int       journal_update_format (journal_t *);
  894. extern int       journal_check_used_features 
  895.            (journal_t *, unsigned long, unsigned long, unsigned long);
  896. extern int       journal_check_available_features 
  897.            (journal_t *, unsigned long, unsigned long, unsigned long);
  898. extern int       journal_set_features 
  899.            (journal_t *, unsigned long, unsigned long, unsigned long);
  900. extern int       journal_create     (journal_t *);
  901. extern int       journal_load       (journal_t *journal);
  902. extern void       journal_destroy    (journal_t *);
  903. extern int       journal_recover    (journal_t *journal);
  904. extern int       journal_wipe       (journal_t *, int);
  905. extern int       journal_skip_recovery    (journal_t *);
  906. extern void       journal_update_superblock    (journal_t *, int);
  907. extern void       __journal_abort_hard    (journal_t *);
  908. extern void       __journal_abort_soft    (journal_t *, int);
  909. extern void       journal_abort      (journal_t *, int);
  910. extern int       journal_errno      (journal_t *);
  911. extern void       journal_ack_err    (journal_t *);
  912. extern int       journal_clear_err  (journal_t *);
  913. extern int       journal_bmap(journal_t *, unsigned long, unsigned long *);
  914. extern int       journal_force_commit(journal_t *);
  915.  
  916. /*
  917.  * journal_head management
  918.  */
  919. struct journal_head *journal_add_journal_head(struct buffer_head *bh);
  920. struct journal_head *journal_grab_journal_head(struct buffer_head *bh);
  921. void journal_remove_journal_head(struct buffer_head *bh);
  922. void journal_put_journal_head(struct journal_head *jh);
  923.  
  924. /*
  925.  * handle management
  926.  */
  927. extern kmem_cache_t *jbd_handle_cache;
  928.  
  929. static inline handle_t *jbd_alloc_handle(int gfp_flags)
  930. {
  931.     return kmem_cache_alloc(jbd_handle_cache, gfp_flags);
  932. }
  933.  
  934. static inline void jbd_free_handle(handle_t *handle)
  935. {
  936.     kmem_cache_free(jbd_handle_cache, handle);
  937. }
  938.  
  939. /* Primary revoke support */
  940. #define JOURNAL_REVOKE_DEFAULT_HASH 256
  941. extern int       journal_init_revoke(journal_t *, int);
  942. extern void       journal_destroy_revoke_caches(void);
  943. extern int       journal_init_revoke_caches(void);
  944.  
  945. extern void       journal_destroy_revoke(journal_t *);
  946. extern int       journal_revoke (handle_t *,
  947.                 unsigned long, struct buffer_head *);
  948. extern int       journal_cancel_revoke(handle_t *, struct journal_head *);
  949. extern void       journal_write_revoke_records(journal_t *, transaction_t *);
  950.  
  951. /* Recovery revoke support */
  952. extern int    journal_set_revoke(journal_t *, unsigned long, tid_t);
  953. extern int    journal_test_revoke(journal_t *, unsigned long, tid_t);
  954. extern void    journal_clear_revoke(journal_t *);
  955. extern void    journal_brelse_array(struct buffer_head *b[], int n);
  956. extern void    journal_switch_revoke_table(journal_t *journal);
  957.  
  958. /*
  959.  * The log thread user interface:
  960.  *
  961.  * Request space in the current transaction, and force transaction commit
  962.  * transitions on demand.
  963.  */
  964.  
  965. int __log_space_left(journal_t *); /* Called with journal locked */
  966. int log_start_commit(journal_t *journal, tid_t tid);
  967. int __log_start_commit(journal_t *journal, tid_t tid);
  968. int journal_start_commit(journal_t *journal, tid_t *tid);
  969. int journal_force_commit_nested(journal_t *journal);
  970. int log_wait_commit(journal_t *journal, tid_t tid);
  971. int log_do_checkpoint(journal_t *journal);
  972.  
  973. void __log_wait_for_space(journal_t *journal);
  974. extern void    __journal_drop_transaction(journal_t *, transaction_t *);
  975. extern int    cleanup_journal_tail(journal_t *);
  976.  
  977. /* Debugging code only: */
  978.  
  979. #define jbd_ENOSYS() \
  980. do {                                           \
  981.     printk (KERN_ERR "JBD unimplemented function %s\n", __FUNCTION__); \
  982.     current->state = TASK_UNINTERRUPTIBLE;                       \
  983.     schedule();                                   \
  984. } while (1)
  985.  
  986. /*
  987.  * is_journal_abort
  988.  *
  989.  * Simple test wrapper function to test the JFS_ABORT state flag.  This
  990.  * bit, when set, indicates that we have had a fatal error somewhere,
  991.  * either inside the journaling layer or indicated to us by the client
  992.  * (eg. ext3), and that we and should not commit any further
  993.  * transactions.  
  994.  */
  995.  
  996. static inline int is_journal_aborted(journal_t *journal)
  997. {
  998.     return journal->j_flags & JFS_ABORT;
  999. }
  1000.  
  1001. static inline int is_handle_aborted(handle_t *handle)
  1002. {
  1003.     if (handle->h_aborted)
  1004.         return 1;
  1005.     return is_journal_aborted(handle->h_transaction->t_journal);
  1006. }
  1007.  
  1008. static inline void journal_abort_handle(handle_t *handle)
  1009. {
  1010.     handle->h_aborted = 1;
  1011. }
  1012.  
  1013. #endif /* __KERNEL__   */
  1014.  
  1015. /* Comparison functions for transaction IDs: perform comparisons using
  1016.  * modulo arithmetic so that they work over sequence number wraps. */
  1017.  
  1018. static inline int tid_gt(tid_t x, tid_t y)
  1019. {
  1020.     int difference = (x - y);
  1021.     return (difference > 0);
  1022. }
  1023.  
  1024. static inline int tid_geq(tid_t x, tid_t y)
  1025. {
  1026.     int difference = (x - y);
  1027.     return (difference >= 0);
  1028. }
  1029.  
  1030. extern int journal_blocks_per_page(struct inode *inode);
  1031.  
  1032. /*
  1033.  * Return the minimum number of blocks which must be free in the journal
  1034.  * before a new transaction may be started.  Must be called under j_state_lock.
  1035.  */
  1036. static inline int jbd_space_needed(journal_t *journal)
  1037. {
  1038.     int nblocks = journal->j_max_transaction_buffers;
  1039.     if (journal->j_committing_transaction)
  1040.         nblocks += journal->j_committing_transaction->
  1041.                     t_outstanding_credits;
  1042.     return nblocks;
  1043. }
  1044.  
  1045. /*
  1046.  * Definitions which augment the buffer_head layer
  1047.  */
  1048.  
  1049. /* journaling buffer types */
  1050. #define BJ_None        0    /* Not journaled */
  1051. #define BJ_SyncData    1    /* Normal data: flush before commit */
  1052. #define BJ_Metadata    2    /* Normal journaled metadata */
  1053. #define BJ_Forget    3    /* Buffer superseded by this transaction */
  1054. #define BJ_IO        4    /* Buffer is for temporary IO use */
  1055. #define BJ_Shadow    5    /* Buffer contents being shadowed to the log */
  1056. #define BJ_LogCtl    6    /* Buffer contains log descriptors */
  1057. #define BJ_Reserved    7    /* Buffer is reserved for access by journal */
  1058. #define BJ_Locked    8    /* Locked for I/O during commit */
  1059. #define BJ_Types    9
  1060.  
  1061. extern int jbd_blocks_per_page(struct inode *inode);
  1062.  
  1063. #ifdef __KERNEL__
  1064.  
  1065. #define buffer_trace_init(bh)    do {} while (0)
  1066. #define print_buffer_fields(bh)    do {} while (0)
  1067. #define print_buffer_trace(bh)    do {} while (0)
  1068. #define BUFFER_TRACE(bh, info)    do {} while (0)
  1069. #define BUFFER_TRACE2(bh, bh2, info)    do {} while (0)
  1070. #define JBUFFER_TRACE(jh, info)    do {} while (0)
  1071.  
  1072. #endif    /* __KERNEL__ */
  1073.  
  1074. #endif    /* CONFIG_JBD || CONFIG_JBD_MODULE || !__KERNEL__ */
  1075.  
  1076. /*
  1077.  * Compatibility no-ops which allow the kernel to compile without CONFIG_JBD
  1078.  * go here.
  1079.  */
  1080.  
  1081. #if defined(__KERNEL__) && !(defined(CONFIG_JBD) || defined(CONFIG_JBD_MODULE))
  1082.  
  1083. #define J_ASSERT(expr)            do {} while (0)
  1084. #define J_ASSERT_BH(bh, expr)        do {} while (0)
  1085. #define buffer_jbd(bh)            0
  1086. #define journal_buffer_journal_lru(bh)    0
  1087.  
  1088. #endif    /* defined(__KERNEL__) && !defined(CONFIG_JBD) */
  1089. #endif    /* _LINUX_JBD_H */
  1090.